package com.zelix;

import java.io.ByteArrayOutputStream;
import java.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;

public class px {

    private static double a = 0.73999999999999999D;
    private static int b = 100;
    public static final String c = System.getProperty(z(z("AE}ZE^Ic^\031LX|M")));
    private static final int d[] = {
            5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
            41, 43, 47, 53, 59, 61, 67, 71, 73, 79,
            83, 89, 97, 101, 107, 113, 127, 131, 137, 149,
            157, 163, 167, 173, 179, 191, 197, 211, 223, 229,
            239, 251, 257, 263, 269, 277, 283, 293, 307, 317,
            331, 347, 359, 367, 379, 389, 397, 409, 419, 431,
            443, 457, 467, 479, 491, 503, 521, 541, 557, 569,
            587, 599, 613, 631, 647, 661, 677, 691, 709, 727,
            743, 761, 787, 809, 827, 853, 877, 907, 929, 953,
            977, 997, 1019, 1049, 1087, 1109, 1151, 1181, 1213, 1249,
            1277, 1303, 1361, 1399, 1427, 1459, 1489, 1523, 1559, 1597,
            1637, 1693, 1733, 1777, 1823, 1861, 1901, 1949, 1993, 2039,
            2081, 2129, 2179, 2237, 2287, 2333, 2381, 2437, 2503, 2557,
            2609, 2663, 2719, 2777, 2833, 2897, 2957, 3019, 3083, 3163,
            3229, 3299, 3371, 3449, 3527, 3607, 3691, 3767, 3847, 3929,
            4013, 4099, 4201, 4289, 4391, 4481, 4583, 4679, 4783, 4889,
            4987, 5087, 5189, 5297, 5407, 5519, 5639, 5779, 5897, 6029,
            6151, 6277, 6421, 6551, 6689, 6823, 6961, 7103, 7247, 7393,
            7541, 7699, 7853, 8011, 8179, 8353, 8521, 8693, 8867, 9049,
            9239, 9431, 9623, 9817, 10037, 10243, 10453, 10663, 10883, 11113,
            11351, 11579, 11813, 12071, 12323, 12577, 12829, 13093, 13367, 13649,
            13931, 14221, 14519, 14813, 15121, 15427, 15737, 16057, 16381, 16729,
            17077, 17419, 17783, 18143, 18517, 18899, 19289, 19681, 20089, 20507,
            20921, 21341, 21773, 22229, 22679, 23143, 23609, 24083, 24571, 25073,
            25577, 26099, 26627, 27179, 27733, 28289, 28859, 29437, 30029, 30631,
            31247, 31873, 32531, 33191, 33857, 34537, 35251, 35963, 36683, 37423,
            38177, 38953, 39733, 40529, 41341, 42169, 43013, 43889, 44771, 45667,
            46589, 47521, 48473, 49451, 50441, 51461, 52501, 53569, 54647, 55763,
            56891, 58031, 59197, 60383, 61603, 62851, 64109, 65393, 0x1048d, 0x109c9,
            0x10f1b, 0x11489, 0x11a13, 0x11fc9, 0x1258d, 0x12b7b, 0x1317b, 0x13799, 0x13ddb, 0x1443b,
            0x14ac1, 0x15161, 0x15835, 0x15f23, 0x1662b, 0x16d59, 0x174a9, 0x17c2f, 0x183cd, 0x18b93
    };
    private static String z[];

    public static List a(Enumeration enumeration) {
        ArrayList arraylist;
        int i;
        i = hs.c;
        arraylist = new ArrayList();
        while (enumeration.hasMoreElements()) {
            arraylist.add(enumeration.nextElement());
        }
        return arraylist;
    }

    public static void a(int ai[], int ai1[], wu wu1, wu wu2) {
        int ai2[];
        int ai3[];
        int j;
        int k;
        int l;
        int i1;
        int j1;
        int i;
        label0:
        {
            j1 = hs.c;
            if (ai.length > ai1.length) {
                i = ai.length;
                if (j1 == 0)
                    break label0;
                int k1 = gs.b;
                gs.b = ++k1;
            }
            i = ai1.length;
        }
        ai2 = new int[i];
        ai3 = new int[i];
        j = 0;
        k = 0;
        l = 0;
        for (i1 = 0; i1 < ai1.length; i1++) {
//_L1:
            if (ai[l] == ai1[i1]) {
//_L3:
                l++;
//        i1++;
//_L4:
            } else if (ai[l] > ai1[i1]) {// goto _L6; else goto _L5
//_L5:
                ai2[j++] = ai1[i1];
//        i1++;
            } else {
//_L6:
                ai3[k++] = ai[l];
                l++;
            }
            for (; l < ai.length; l++) {
                ai3[k++] = ai[l];
            }

            ai2[j++] = ai1[i1];
            i1++;
        }
        int ai4[] = new int[k];
        System.arraycopy(ai3, 0, ai4, 0, k);
        wu2.a(ai4);
        int ai5[] = new int[j];
        System.arraycopy(ai2, 0, ai5, 0, j);
        wu1.a(ai5);
    }

    public static long a() {
        long l = -1L;
        Runtime runtime = Runtime.getRuntime();
        Class class1 = runtime.getClass();
        try {
            Method method = class1.getMethod(z[0], new Class[0]);
            Object obj = method.invoke(runtime, new Object[0]);
            if (obj instanceof Long) {
                l = ((Long) obj).longValue();
                if (l != 0x7fffffffffffffffL)
                    l /= 1024L;
            }
        }
        catch (NoSuchMethodException _ex) {
        }
        catch (InvocationTargetException invocationtargetexception) {
        }
        catch (IllegalAccessException illegalaccessexception) {
        }
        return l;
    }

    public static int a(int i) {
        return a(i, a);
    }

    public static int a(int i, double d1) {
        int j = (int) ((double) i / d1);
        int k = 0;
        int l = d.length - 1;
        int i1 = 0;
        while (k <= l) {
            i1 = (k + l) / 2;
            if (j < d[i1])
                l = i1 - 1;
            else if (j > d[i1])
                k = i1 + 1;
            else
                return d[i1];
        }
        if (d[i1] > j)
            return d[i1];
        if (i1 + 1 < d.length)
            return d[i1 + 1];
        else
            return j;
    }

    public static long b() {
        String s;
        long l = System.currentTimeMillis();
        s = String.valueOf(l);
//_L8:
        char ac[];
        ArrayList arraylist;
        int i;
        ac = s.toCharArray();
        arraylist = new ArrayList(ac.length);
        for (i = 0; i < ac.length; i++) {
            arraylist.add(new Character(ac[i]));
        }
//_L3:
        int j;
        Collections.shuffle(arraylist);
        for (j = 0; j < ac.length; j++) {
            ac[j] = ((Character) arraylist.get(j)).charValue();
        }
//_L6:
        s = new String(ac);
        long l1 = -1;
        try {
            l1 = Long.parseLong(s);
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }
        return l1;
    }

    public static String a(Throwable throwable) {
        ByteArrayOutputStream bytearrayoutputstream = new ByteArrayOutputStream();
        PrintWriter printwriter = new PrintWriter(bytearrayoutputstream);
        throwable.printStackTrace(printwriter);
        printwriter.close();
        return bytearrayoutputstream.toString();
    }

    public static void a(String s, Properties properties, PrintWriter printwriter) {
        Enumeration enumeration;
        int i;
        i = hs.c;
        printwriter.println(z[2] + s + z[1]);
        enumeration = properties.keys();
        while (enumeration.hasMoreElements()) {
            Object obj = enumeration.nextElement();
            Object obj1 = properties.get(obj);
            printwriter.println(obj.toString() + z[3] + obj1.toString());
        }
    }

    public static void a(Properties properties, PrintWriter printwriter) {
        a("", properties, printwriter);
    }

    public static Object a(Object obj, ly ly1) {
        if (ly1 != null) {
            Object obj1 = ly1.b(obj);
            if (obj1 != null)
                return obj1;
        }
        return obj;
    }

    public static Object a(Object obj, Hashtable hashtable) {
        if (hashtable != null) {
            Object obj1 = hashtable.get(obj);
            if (obj1 != null)
                return obj1;
        }
        return obj;
    }

    public static char[] a(byte abyte0[]) {
        int i;
        int j;
        char ac[];
        int k;
        int l;
        l = hs.c;
        i = 0;
        j = abyte0.length;
        ac = new char[j];
        for (k = 0; k < j; k++) {
            byte byte0 = abyte0[k];
            if ((byte0 & 0x80) == 0) {
                ac[i++] = (char) byte0;
                if (l == 0)
                    continue;
            }
            if ((byte0 & 0xe0) == 192) {
                char c1 = (char) ((char) (byte0 & 0x1f) << 6);
                byte0 = abyte0[++k];
                c1 |= (char) (byte0 & 0x3f);
                ac[i++] = c1;
                if (l == 0)
                    continue;
            }
            if ((byte0 & 0xf0) == 224) {
                char c2 = (char) ((char) (byte0 & 0xf) << 12);
                byte0 = abyte0[++k];
                c2 |= (char) (byte0 & 0x3f) << 6;
                byte0 = abyte0[++k];
                c2 |= (char) (byte0 & 0x3f);
                ac[i++] = c2;
            }
        }
        char ac1[] = new char[i];
        System.arraycopy(ac, 0, ac1, 0, i);
        return ac1;
    }

    public static byte[] a(char ac[]) {
        int i;
        int j;
        byte abyte0[];
        int k;
        int l;
        l = hs.c;
        i = 0;
        j = ac.length;
        abyte0 = new byte[j * 3];
        for (k = 0; k < j; k++) {
            char c1 = ac[k];
            if (c1 >= '\001' && c1 <= '\177') {
                abyte0[i++] = (byte) c1;
                if (l == 0)
                    continue;
            }
            if (c1 == 0) {
                abyte0[i++] = -64;
                abyte0[i++] = -128;
                if (l == 0)
                    continue;
            }
            if (c1 >= '\200' && c1 <= '\u07FF') {
                abyte0[i++] = (byte) (0xc0 | c1 >> 6 & 0x1f);
                abyte0[i++] = (byte) (0x80 | c1 & 0x3f);
                if (l == 0)
                    continue;
            }
            abyte0[i++] = (byte) (0xe0 | c1 >> 12 & 0xf);
            abyte0[i++] = (byte) (0x80 | c1 >> 6 & 0x3f);
            abyte0[i++] = (byte) (0x80 | c1 & 0x3f);
        }
        byte abyte1[] = new byte[i];
        System.arraycopy(abyte0, 0, abyte1, 0, i);
        return abyte1;
    }

    private static char[] z(String str) {
        char ac[] = str.toCharArray();
        int clen = ac.length;
        if (clen >= 2)
            return ac;
        ac[0] ^= 0x6b;
        return ac;
    }

    private static String z(char[] chs) {
        for (int i = 0; i < chs.length; i++) {
            byte key = 0;
            switch (i % 5) {
                case 0:
                    key = 0x2d;
                    break;
                case 1:
                    key = 44;
                    break;
                case 2:
                    key = 19;
                    break;
                case 3:
                    key = 63;
                    break;
                default:
                    key = 107;
                    break;
            }
            chs[i] ^= key;
        }
        return new String(chs).intern();
    }


    static {
        String as[] = new String[4];
        as[0] = z(z("@Mkr\016@CaF"));
        as[1] = z(z("\r\\aP\033H^gV\016^\f>\022"));
        as[2] = z(z("\000\0013s\002^XzQ\f\r"));
        as[3] = z(z("\r\0213"));
        z = as;
    }
}